home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 2003 August / MW 8 2003 CD1.iso / Inside Macworld / Product News / gimp-1.2.4.sit / gimp-1.2.4 / app / brightness_contrast.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-12-29  |  13.7 KB  |  513 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include <gtk/gtk.h>
  22.  
  23. #include "apptypes.h"
  24.  
  25. #include "appenv.h"
  26. #include "brightness_contrast.h"
  27. #include "drawable.h"
  28. #include "gimplut.h"
  29. #include "gimpui.h"
  30. #include "gdisplay.h"
  31. #include "image_map.h"
  32. #include "lut_funcs.h"
  33.  
  34. #include "libgimp/gimpintl.h"
  35.  
  36. #define SLIDER_WIDTH 200
  37.  
  38. #define BRIGHTNESS  0x1
  39. #define CONTRAST    0x2
  40. #define ALL        (BRIGHTNESS | CONTRAST)
  41.  
  42. /*  the brightness-contrast structures  */
  43.  
  44. typedef struct _BrightnessContrast BrightnessContrast;
  45.  
  46. struct _BrightnessContrast
  47. {
  48.   gint x, y;    /*  coords for last mouse click  */
  49. };
  50.  
  51. typedef struct _BrightnessContrastDialog BrightnessContrastDialog;
  52.  
  53. struct _BrightnessContrastDialog
  54. {
  55.   GtkWidget     *shell;
  56.   GtkWidget     *gimage_name;
  57.  
  58.   GtkAdjustment *brightness_data;
  59.   GtkAdjustment *contrast_data;
  60.  
  61.   GimpDrawable  *drawable;
  62.   ImageMap       image_map;
  63.  
  64.   gdouble        brightness;
  65.   gdouble        contrast;
  66.  
  67.   gboolean       preview;
  68.   GimpLut       *lut;
  69.  
  70.   glong          conn_id;
  71. };
  72.  
  73.  
  74. /*  the brightness-contrast tool options  */
  75. static ToolOptions *brightness_contrast_options = NULL;
  76.  
  77. /*  the brightness-contrast dialog  */
  78. static BrightnessContrastDialog *brightness_contrast_dialog = NULL;
  79.  
  80.  
  81. /*  brightness contrast action functions  */
  82.  
  83. static void   brightness_contrast_control (Tool *, ToolAction, gpointer);
  84.  
  85. static BrightnessContrastDialog * brightness_contrast_dialog_new (void);
  86.  
  87. static void   brightness_contrast_update          (BrightnessContrastDialog *,
  88.                            gint);
  89. static void   brightness_contrast_preview         (BrightnessContrastDialog *);
  90. static void   brightness_contrast_reset_callback  (GtkWidget *, gpointer);
  91. static void   brightness_contrast_ok_callback     (GtkWidget *, gpointer);
  92. static void   brightness_contrast_cancel_callback (GtkWidget *, gpointer);
  93. static void   brightness_contrast_preview_update  (GtkWidget *, gpointer);
  94. static void   brightness_contrast_brightness_adjustment_update (GtkAdjustment *,
  95.                                 gpointer);
  96. static void   brightness_contrast_contrast_adjustment_update   (GtkAdjustment *,
  97.                                 gpointer);
  98.  
  99. /*  brightness-contrast select action functions  */
  100.  
  101. static void
  102. brightness_contrast_control (Tool       *tool,
  103.                  ToolAction  action,
  104.                  gpointer    gdisp_ptr)
  105. {
  106.   switch (action)
  107.     {
  108.     case PAUSE:
  109.       break;
  110.  
  111.     case RESUME:
  112.       break;
  113.  
  114.     case HALT:
  115.       brightness_contrast_dialog_hide ();
  116.       break;
  117.  
  118.     default:
  119.       break;
  120.     }
  121. }
  122.  
  123. Tool *
  124. tools_new_brightness_contrast (void)
  125. {
  126.   Tool * tool;
  127.   BrightnessContrast * private;
  128.  
  129.   /*  The tool options  */
  130.   if (!brightness_contrast_options)
  131.     {
  132.       brightness_contrast_options =
  133.     tool_options_new (_("Brightness-Contrast"));
  134.       tools_register (BRIGHTNESS_CONTRAST, brightness_contrast_options);
  135.    }
  136.  
  137.   tool = tools_new_tool (BRIGHTNESS_CONTRAST);
  138.   private = g_new0 (BrightnessContrast, 1);
  139.  
  140.   tool->scroll_lock = TRUE;   /*  Disallow scrolling  */
  141.   tool->preserve    = FALSE;  /*  Don't preserve on drawable change  */
  142.  
  143.   tool->private = (void *) private;
  144.  
  145.   tool->control_func = brightness_contrast_control;
  146.  
  147.   return tool;
  148. }
  149.  
  150. void
  151. brightness_contrast_dialog_hide (void)
  152. {
  153.   if (brightness_contrast_dialog)
  154.     brightness_contrast_cancel_callback (NULL,
  155.                                      (gpointer) brightness_contrast_dialog);
  156. } 
  157.   
  158. void
  159. tools_free_brightness_contrast (Tool *tool)
  160. {
  161.   BrightnessContrast * bc;
  162.  
  163.   bc = (BrightnessContrast *) tool->private;
  164.  
  165.   /*  Close the brightness-contrast dialog  */
  166.   brightness_contrast_dialog_hide ();
  167.  
  168.   g_free (bc);
  169. }
  170.  
  171. void
  172. brightness_contrast_initialize (GDisplay *gdisp)
  173. {
  174.   if (gimp_image_is_empty (gdisp->gimage))
  175.     {
  176.       g_message (_("The image has no drawables."));
  177.       return;
  178.     }
  179.  
  180.   if (drawable_indexed (gimage_active_drawable (gdisp->gimage)))
  181.     {
  182.       g_message (_("Brightness-Contrast does not operate on indexed drawables."));
  183.       return;
  184.     }
  185.  
  186.   /*  The brightness-contrast dialog  */
  187.   if (!brightness_contrast_dialog)
  188.     brightness_contrast_dialog = brightness_contrast_dialog_new ();
  189.   else
  190.     if (!GTK_WIDGET_VISIBLE (brightness_contrast_dialog->shell))
  191.       gtk_widget_show (brightness_contrast_dialog->shell);
  192.  
  193.   brightness_contrast_dialog->brightness = 0.0;
  194.   brightness_contrast_dialog->contrast   = 0.0;
  195.  
  196.   brightness_contrast_dialog->drawable = gimage_active_drawable (gdisp->gimage);
  197.   brightness_contrast_dialog->image_map =
  198.     image_map_create (gdisp, brightness_contrast_dialog->drawable);
  199.  
  200.   brightness_contrast_update (brightness_contrast_dialog, ALL);
  201.  
  202.   /* Merge-related undo release signal */
  203.  
  204.   brightness_contrast_dialog->conn_id = 
  205.     gtk_signal_connect (GTK_OBJECT (gdisp->gimage), "layer_merge",
  206.             GTK_SIGNAL_FUNC (brightness_contrast_cancel_callback),
  207.             brightness_contrast_dialog);
  208. }
  209.  
  210. /********************************/
  211. /*  Brightness Contrast dialog  */
  212. /********************************/
  213.  
  214. static BrightnessContrastDialog *
  215. brightness_contrast_dialog_new (void)
  216. {
  217.   BrightnessContrastDialog *bcd;
  218.   GtkWidget *vbox;
  219.   GtkWidget *hbox;
  220.   GtkWidget *table;
  221.   GtkWidget *label;
  222.   GtkWidget *abox;
  223.   GtkWidget *spinbutton;
  224.   GtkWidget *slider;
  225.   GtkWidget *toggle;
  226.   GtkObject *data;
  227.  
  228.   bcd = g_new (BrightnessContrastDialog, 1);
  229.   bcd->preview = TRUE;
  230.  
  231.   bcd->lut = gimp_lut_new ();
  232.  
  233.   /*  The shell and main vbox  */
  234.   bcd->shell =
  235.     gimp_dialog_new (_("Brightness-Contrast"), "brightness_contrast",
  236.              tools_help_func, NULL,
  237.              GTK_WIN_POS_NONE,
  238.              FALSE, TRUE, FALSE,
  239.  
  240.              _("OK"), brightness_contrast_ok_callback,
  241.              bcd, NULL, NULL, TRUE, FALSE,
  242.              _("Reset"), brightness_contrast_reset_callback,
  243.              bcd, NULL, NULL, TRUE, FALSE,
  244.              _("Cancel"), brightness_contrast_cancel_callback,
  245.              bcd, NULL, NULL, FALSE, TRUE,
  246.  
  247.              NULL);
  248.  
  249.   vbox = gtk_vbox_new (FALSE, 4);
  250.   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
  251.   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (bcd->shell)->vbox), vbox);
  252.  
  253.   /*  The table containing sliders  */
  254.   table = gtk_table_new (2, 3, FALSE);
  255.   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
  256.   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  257.   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  258.  
  259.   /*  Create the brightness scale widget  */
  260.   label = gtk_label_new (_("Brightness:"));
  261.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  262.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
  263.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  264.  
  265.   data = gtk_adjustment_new (0, -127, 127.0, 1.0, 10.0, 0.0);
  266.   bcd->brightness_data = GTK_ADJUSTMENT (data);
  267.   slider = gtk_hscale_new (GTK_ADJUSTMENT (data));
  268.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  269.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  270.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  271.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  272.   gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, 0, 1);
  273.  
  274.   abox = gtk_vbox_new (FALSE, 0);
  275.   spinbutton = gtk_spin_button_new (bcd->brightness_data, 1.0, 0);
  276.   gtk_widget_set_usize (spinbutton, 75, -1);
  277.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  278.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 0, 1,
  279.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  280.  
  281.   gtk_signal_connect (GTK_OBJECT (data), "value_changed",
  282.               GTK_SIGNAL_FUNC (brightness_contrast_brightness_adjustment_update),
  283.               bcd);
  284.  
  285.   gtk_widget_show (label);
  286.   gtk_widget_show (slider);
  287.   gtk_widget_show (spinbutton);
  288.   gtk_widget_show (abox);
  289.  
  290.   /*  Create the contrast scale widget  */
  291.   label = gtk_label_new (_("Contrast:"));
  292.   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  293.   gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
  294.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  295.  
  296.   data = gtk_adjustment_new (0, -127.0, 127.0, 1.0, 10.0, 0.0);
  297.   bcd->contrast_data = GTK_ADJUSTMENT (data);
  298.   slider = gtk_hscale_new (GTK_ADJUSTMENT (data));
  299.   gtk_widget_set_usize (slider, SLIDER_WIDTH, -1);
  300.   gtk_scale_set_digits (GTK_SCALE (slider), 0);
  301.   gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
  302.   gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
  303.   gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, 1, 2);
  304.  
  305.   abox = gtk_vbox_new (FALSE, 0);
  306.   spinbutton = gtk_spin_button_new (bcd->contrast_data, 1.0, 0);
  307.   gtk_widget_set_usize (spinbutton, 75, -1);
  308.   gtk_box_pack_end (GTK_BOX (abox), spinbutton, FALSE, FALSE, 0);
  309.   gtk_table_attach (GTK_TABLE (table), abox, 2, 3, 1, 2,
  310.             GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
  311.  
  312.   gtk_signal_connect (GTK_OBJECT (data), "value_changed",
  313.               GTK_SIGNAL_FUNC (brightness_contrast_contrast_adjustment_update),
  314.               bcd);
  315.  
  316.   gtk_widget_show (label);
  317.   gtk_widget_show (slider);
  318.   gtk_widget_show (spinbutton);
  319.   gtk_widget_show (abox);
  320.  
  321.   /*  Horizontal box for preview toggle button  */
  322.   hbox = gtk_hbox_new (FALSE, 4);
  323.   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  324.  
  325.   /*  The preview toggle  */
  326.   toggle = gtk_check_button_new_with_label (_("Preview"));
  327.   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bcd->preview);
  328.   gtk_box_pack_end (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
  329.   gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
  330.               GTK_SIGNAL_FUNC (brightness_contrast_preview_update),
  331.               bcd);
  332.  
  333.   gtk_widget_show (toggle);
  334.   gtk_widget_show (hbox);
  335.  
  336.   gtk_widget_show (table);
  337.   gtk_widget_show (vbox);
  338.   gtk_widget_show (bcd->shell);
  339.  
  340.   return bcd;
  341. }
  342.  
  343. static void
  344. brightness_contrast_update (BrightnessContrastDialog *bcd,
  345.                 gint                      update)
  346. {
  347.   if (update & BRIGHTNESS)
  348.     {
  349.       gtk_adjustment_set_value (bcd->brightness_data, bcd->brightness);
  350.     }
  351.   if (update & CONTRAST)
  352.     {
  353.       gtk_adjustment_set_value (bcd->contrast_data, bcd->contrast);
  354.     }
  355. }
  356.  
  357. static void
  358. brightness_contrast_preview (BrightnessContrastDialog *bcd)
  359. {
  360.   if (!bcd->image_map)
  361.     {
  362.       g_message ("brightness_contrast_preview(): No image map");
  363.       return;
  364.     }
  365.  
  366.   active_tool->preserve = TRUE;
  367.   brightness_contrast_lut_setup (bcd->lut, bcd->brightness / 255.0,
  368.                  bcd->contrast / 127.0,
  369.                  gimp_drawable_bytes (bcd->drawable));
  370.   image_map_apply (bcd->image_map, (ImageMapApplyFunc) gimp_lut_process_2,
  371.            (void *) bcd->lut);
  372.   active_tool->preserve = FALSE;
  373. }
  374.  
  375. static void
  376. brightness_contrast_reset_callback (GtkWidget *widget,
  377.                     gpointer   data)
  378. {
  379.   BrightnessContrastDialog *bcd;
  380.  
  381.   bcd = (BrightnessContrastDialog *) data;
  382.  
  383.   bcd->brightness = 0.0;
  384.   bcd->contrast   = 0.0;
  385.  
  386.   brightness_contrast_update (bcd, ALL);
  387.  
  388.   if (bcd->preview)
  389.     brightness_contrast_preview (bcd);
  390. }
  391.  
  392. static void
  393. brightness_contrast_ok_callback (GtkWidget *widget,
  394.                  gpointer   data)
  395. {
  396.   BrightnessContrastDialog *bcd;
  397.  
  398.   bcd = (BrightnessContrastDialog *) data;
  399.  
  400.   gimp_dialog_hide (bcd->shell);
  401.  
  402.   active_tool->preserve = TRUE;
  403.  
  404.   if (!bcd->preview)
  405.   {
  406.     brightness_contrast_lut_setup (bcd->lut, bcd->brightness / 255.0,
  407.                    bcd->contrast / 127.0,
  408.                    gimp_drawable_bytes (bcd->drawable));
  409.     image_map_apply (bcd->image_map, (ImageMapApplyFunc) gimp_lut_process_2,
  410.              (void *) bcd->lut);
  411.   }
  412.  
  413.   if (bcd->image_map)
  414.     image_map_commit (bcd->image_map);
  415.  
  416.   active_tool->preserve = FALSE;
  417.  
  418.   bcd->image_map = NULL;
  419.  
  420.   active_tool->gdisp_ptr = NULL;
  421.   active_tool->drawable = NULL;
  422. }
  423.  
  424. static void
  425. brightness_contrast_cancel_callback (GtkWidget *widget,
  426.                      gpointer   data)
  427. {
  428.   BrightnessContrastDialog *bcd;
  429.  
  430.   bcd = (BrightnessContrastDialog *) data;
  431.  
  432.   gimp_dialog_hide (bcd->shell);
  433.  
  434.   if (bcd->image_map)
  435.     {
  436.       active_tool->preserve = TRUE;
  437.       image_map_abort (bcd->image_map);
  438.       active_tool->preserve = FALSE;
  439.  
  440.       bcd->image_map = NULL;
  441.       gdisplays_flush ();
  442.     }
  443.  
  444.   if (bcd->conn_id != 0)
  445.     {
  446.       gtk_signal_disconnect (GTK_OBJECT (gimp_drawable_gimage (bcd->drawable)), bcd->conn_id);
  447.       bcd->conn_id = 0;
  448.     }
  449.  
  450.   active_tool->gdisp_ptr = NULL;
  451.   active_tool->drawable = NULL;
  452. }
  453.  
  454. static void
  455. brightness_contrast_preview_update (GtkWidget *widget,
  456.                     gpointer   data)
  457. {
  458.   BrightnessContrastDialog *bcd;
  459.  
  460.   bcd = (BrightnessContrastDialog *) data;
  461.  
  462.   if (GTK_TOGGLE_BUTTON (widget)->active)
  463.     {
  464.       bcd->preview = TRUE;
  465.       brightness_contrast_preview (bcd);
  466.     }
  467.   else
  468.     {
  469.       bcd->preview = FALSE;
  470.       if (bcd->image_map)
  471.     {
  472.       active_tool->preserve = TRUE;
  473.       image_map_clear (bcd->image_map);
  474.       active_tool->preserve = FALSE;
  475.       gdisplays_flush ();
  476.     }
  477.     }
  478. }
  479.  
  480. static void
  481. brightness_contrast_brightness_adjustment_update (GtkAdjustment *adjustment,
  482.                           gpointer       data)
  483. {
  484.   BrightnessContrastDialog *bcd;
  485.  
  486.   bcd = (BrightnessContrastDialog *) data;
  487.  
  488.   if (bcd->brightness != adjustment->value)
  489.     {
  490.       bcd->brightness = adjustment->value;
  491.  
  492.       if (bcd->preview)
  493.     brightness_contrast_preview (bcd);
  494.     }
  495. }
  496.  
  497. static void
  498. brightness_contrast_contrast_adjustment_update (GtkAdjustment *adjustment,
  499.                         gpointer       data)
  500. {
  501.   BrightnessContrastDialog *bcd;
  502.  
  503.   bcd = (BrightnessContrastDialog *) data;
  504.  
  505.   if (bcd->contrast != adjustment->value)
  506.     {
  507.       bcd->contrast = adjustment->value;
  508.  
  509.       if (bcd->preview)
  510.     brightness_contrast_preview (bcd);
  511.     }
  512. }
  513.